// 告警管理状态管理
import { defineStore } from 'pinia'
import * as alertApi from '@/api/alert.js'
import wsManager from '@/utils/websocket.js'

export const useAlertStore = defineStore('alert', {
  state: () => ({
    // 告警列表
    alertList: [],
    
    // 告警规则
    alertRules: [],
    
    // 告警统计
    alertStats: {
      unhandled: 0,
      confirmed: 0,
      handled: 0,
      total: 0
    },
    
    // 当前选中的告警
    currentAlert: null,
    
    // 告警通知设置
    notificationSettings: {
      enabled: true,
      sound: true,
      vibration: true,
      push: true
    },
    
    // 加载状态
    loading: false,
    
    // 错误信息
    error: null,
    
    // WebSocket连接状态
    wsConnected: false,
    ws: null
  }),

  getters: {
    // 获取未处理告警
    getUnhandledAlerts: (state) => {
      return state.alertList.filter(alert => alert.status === 1)
    },
    
    // 获取已确认告警
    getConfirmedAlerts: (state) => {
      return state.alertList.filter(alert => alert.status === 2)
    },
    
    // 获取已处理告警
    getHandledAlerts: (state) => {
      return state.alertList.filter(alert => alert.status === 3)
    },
    
    // 获取告警级别颜色
    getAlertLevelColor: (state) => (level) => {
      const colorMap = {
        1: '#4cd964', // 低级别 - 绿色
        2: '#f0ad4e', // 中级别 - 橙色
        3: '#dd524d', // 高级别 - 红色
        4: '#8e44ad'  // 紧急 - 紫色
      }
      return colorMap[level] || '#999999'
    },
    
    // 获取告警级别文本
    getAlertLevelText: (state) => (level) => {
      const textMap = {
        1: '低',
        2: '中',
        3: '高',
        4: '紧急'
      }
      return textMap[level] || '低'
    },
    
    // 获取告警状态颜色
    getAlertStatusColor: (state) => (status) => {
      const colorMap = {
        1: '#dd524d', // 未处理 - 红色
        2: '#f0ad4e', // 已确认 - 橙色
        3: '#4cd964'  // 已处理 - 绿色
      }
      return colorMap[status] || '#999999'
    },
    
    // 获取告警状态文本
    getAlertStatusText: (state) => (status) => {
      const textMap = {
        1: '未处理',
        2: '已确认',
        3: '已处理'
      }
      return textMap[status] || '正常'
    },
    
    // 获取告警统计
    getAlertStatistics: (state) => {
      const stats = {
        unhandled: 0,
        confirmed: 0,
        handled: 0,
        total: state.alertList.length
      }
      
      state.alertList.forEach(alert => {
        switch (alert.status) {
          case 1:
            stats.unhandled++
            break
          case 2:
            stats.confirmed++
            break
          case 3:
            stats.handled++
            break
        }
      })
      
      return stats
    }
  },

  actions: {
    // 设置告警列表
    setAlertList(alerts) {
      this.alertList = alerts
      // 统计数据由后端API提供，不在这里更新
    },
    
    // 添加告警
    addAlert(alert) {
      console.log('➕ 尝试添加告警:', alert)
      console.log('➕ 当前告警列表长度:', this.alertList.length)
      
      // 检查是否已存在相同的告警（避免重复）
      const existingAlert = this.alertList.find(item => 
        item.alertId === alert.alertId || // 优先使用alertId匹配
        (item.title === alert.title && 
         item.deviceId === alert.deviceId &&
         item.currentValue === alert.currentValue &&
         Math.abs(new Date(item.createTime) - new Date(alert.createTime)) < 30000) // 30秒内相同数据
      )
      
      if (existingAlert) {
        console.log('⚠️ 发现重复告警，跳过添加:', {
          existing: existingAlert.alertId,
          new: alert.alertId,
          reason: existingAlert.alertId === alert.alertId ? 'alertId相同' : '时间和设备相同'
        })
        return
      }
      
      console.log('✅ 添加新告警到列表')
      this.alertList.unshift(alert)
      // 统计数据由后端API提供，不在这里更新
      console.log('✅ 告警列表更新后长度:', this.alertList.length)
      
      // 触发通知
      this.triggerNotification(alert)
    },
    
    // receiveRealtimeAlert方法已移除，统一使用WebSocket处理实时告警
    
    // 映射严重程度到告警级别
    mapSeverityToLevel(severity) {
      // 后端返回的是数字：1-轻微，2-中等，3-严重
      if (typeof severity === 'number') {
        const levelMap = {
          1: 'low',    // 低级别
          2: 'medium', // 中级别  
          3: 'high'    // 高级别
        }
        return levelMap[severity] || 'low'
      }
      
      // 兼容字符串格式
      const levelMap = {
        'low': 'low',    // 低级别
        'medium': 'medium', // 中级别  
        'high': 'high'    // 高级别
      }
      return levelMap[severity] || 'low'
    },
    
    // 格式化设备ID显示
    formatDeviceId(deviceId) {
      if (!deviceId) return 'ESP8266_001'
      
      // 如果是数字ID，格式化为ESP8266_XXX格式
      if (/^\d+$/.test(deviceId.toString())) {
        return `ESP8266_${deviceId.toString().padStart(3, '0')}`
      }
      
      // 如果已经是ESP8266格式，直接返回
      if (deviceId.toString().startsWith('ESP8266_')) {
        return deviceId.toString()
      }
      
      // 其他情况，添加ESP8266前缀
      return `ESP8266_${deviceId}`
    },
    
    // 映射指标代码到中文名称
    
    // 更新统计信息（基于当前加载的数据）
    updateStats() {
      const stats = {
        unhandled: 0,
        confirmed: 0,
        handled: 0,
        total: this.alertList.length
      }
      
      this.alertList.forEach(alert => {
        switch (alert.status) {
          case 1:
            stats.unhandled++
            break
          case 2:
            stats.confirmed++
            break
          case 3:
            stats.handled++
            break
        }
      })
      
      this.alertStats = stats
    },
    
    // 从后端更新统计数据（基于所有告警数据）
    async updateStatsFromBackend() {
      try {
        console.log('📊 正在从后端更新统计数据...')
        
        const response = await uni.request({
          url: 'http://localhost:8891/Alert/stats',
          method: 'GET'
        })
        
        if (response.data && response.data.code === 200) {
          this.alertStats = response.data.obj
          console.log('✅ 后端统计数据更新完成:', this.alertStats)
        } else {
          console.warn('⚠️ 后端统计数据更新失败，使用本地计算')
          this.updateStats()
        }
      } catch (error) {
        console.error('❌ 从后端更新统计数据失败:', error)
        console.warn('⚠️ 使用本地计算统计数据')
        this.updateStats()
      }
    },
    
    // 触发通知
    triggerNotification(alert) {
      if (this.notificationSettings.enabled) {
        // 显示Toast通知
        uni.showToast({
          title: `新告警: ${alert.title}`,
          icon: 'none',
          duration: 3000
        })
        
        // 可以添加声音、震动等通知
        if (this.notificationSettings.sound) {
          // 播放提示音
        }
        
        if (this.notificationSettings.vibration) {
          // 震动提示
        }
      }
    },
    
    // 保存告警到后端
    async saveAlertToBackend(alert) {
      try {
        // 调用后端API保存告警数据
        const alertData = {
          indicator: alert.indicator,
          currentValue: alert.currentValue,
          normalRange: alert.normalRange,
          deviceId: alert.deviceId,
          dataId: alert.dataId || 0,
          severity: alert.severity
        }
        
        // 这里可以调用后端API
        // await post('/Alert/add', alertData)
        console.log('告警数据已发送到后端:', alertData)
      } catch (error) {
        console.error('保存告警到后端失败:', error)
      }
    },
    
    // 更新告警
    updateAlert(alertId, updates) {
      const index = this.alertList.findIndex(alert => alert.alertId === alertId)
      if (index !== -1) {
        this.alertList[index] = { ...this.alertList[index], ...updates }
      }
    },
    
    // 删除告警
    removeAlert(alertId) {
      const index = this.alertList.findIndex(alert => alert.alertId === alertId)
      if (index !== -1) {
        this.alertList.splice(index, 1)
      }
    },
    
    // 确认告警
    confirmAlert(alertId, handlerId) {
      this.updateAlert(alertId, {
        status: 2,
        handlerId: handlerId,
        handleTime: new Date()
      })
    },
    
    // 处理告警
    handleAlert(alertId, handlerId) {
      this.updateAlert(alertId, {
        status: 3,
        handlerId: handlerId,
        handleTime: new Date()
      })
    },
    
    // 设置告警规则
    setAlertRules(rules) {
      this.alertRules = rules
    },
    
    // 添加告警规则
    addAlertRule(rule) {
      this.alertRules.push(rule)
    },
    
    // 更新告警规则
    updateAlertRule(ruleId, updates) {
      const index = this.alertRules.findIndex(rule => rule.ruleId === ruleId)
      if (index !== -1) {
        this.alertRules[index] = { ...this.alertRules[index], ...updates }
      }
    },
    
    // 删除告警规则
    removeAlertRule(ruleId) {
      const index = this.alertRules.findIndex(rule => rule.ruleId === ruleId)
      if (index !== -1) {
        this.alertRules.splice(index, 1)
      }
    },
    
    // 设置当前告警
    setCurrentAlert(alert) {
      this.currentAlert = alert
    },
    
    // 更新通知设置
    updateNotificationSettings(settings) {
      this.notificationSettings = { ...this.notificationSettings, ...settings }
    },
    
    // 设置加载状态
    setLoading(loading) {
      this.loading = loading
    },
    
    // 设置错误信息
    setError(error) {
      this.error = error
    },
    
    // 清除错误信息
    clearError() {
      this.error = null
    },
    
    // 从数据库加载告警数据
    async loadAlertsFromDatabase(params = {}) {
      try {
        this.setLoading(true)
        this.clearError()
        
        const response = await alertApi.getAlertList(params)
        
        if (response && response.obj && response.obj.data) {
          // 转换后端数据格式为前端格式
          const alerts = response.obj.data.map(item => {
            const chineseIndicator = this.mapIndicatorToChinese(item.indicatorCode)
            console.log('🔍 告警数据项:', item)
            return {
              alertId: item.anomalyId || item.id || item.alertId,
              title: chineseIndicator + '异常', // 使用中文指标名称生成标题
              description: chineseIndicator + '值 ' + item.currentValue + ' 超出正常范围 ' + item.normalRange, // 生成描述
              device: this.formatDeviceId(item.deviceId), // 格式化设备ID显示
              deviceId: item.deviceId,
              indicator: item.indicatorCode, // 保留原始指标代码
              indicatorChinese: chineseIndicator, // 添加中文指标名称
              currentValue: item.currentValue,
              normalRange: item.normalRange,
              level: this.mapSeverityToLevel(item.severity),
              severity: item.severity,
              status: item.handleStatus || 1,
              createTime: item.createTime,
              time: new Date(item.createTime),
              handlerId: 'system', // 默认处理人
              handleTime: null // 处理时间为空
            }
          })
          
          // 按创建时间降序排序（最新的在前面）
          const sortedAlerts = alerts.sort((a, b) => {
            const timeA = new Date(a.createTime || a.time).getTime()
            const timeB = new Date(b.createTime || b.time).getTime()
            return timeB - timeA // 降序排列
          })
          
          this.setAlertList(sortedAlerts)
          this.updateStats()
          
          console.log('从数据库加载告警数据成功:', sortedAlerts.length, '条')
          return sortedAlerts
        } else {
          console.log('没有告警数据')
          this.setAlertList([])
          this.updateStats()
          return []
        }
      } catch (error) {
        console.error('从数据库加载告警数据失败:', error)
        this.setError(error.message || '加载告警数据失败')
        throw error
      } finally {
        this.setLoading(false)
      }
    },
    
    // 初始化WebSocket连接
    initWebSocketConnection() {
      try {
        const BASE_URL = 'http://127.0.0.1:8891'
        
        console.log('🔌 尝试连接告警WebSocket...')
        
        wsManager.createAlertConnection(BASE_URL, {
          onOpen: () => {
            console.log('✅ 告警WebSocket连接已建立')
            this.wsConnected = true
            // 设置心跳检测
            this.startHeartbeat()
            // 监听自定义事件
            this.setupEventListeners()
          },
          onMessage: (message) => {
            console.log('📨 收到WebSocket消息:', message)
            this.handleRealtimeAlert(message)
          },
          onClose: (event) => {
            console.log('❌ 告警WebSocket连接已关闭:', event.code, event.reason)
            this.wsConnected = false
            this.stopHeartbeat()
          },
          onError: (error) => {
            console.error('🚨 告警WebSocket连接错误:', error)
            this.wsConnected = false
            this.stopHeartbeat()
          },
          autoReconnect: true
        })
      } catch (error) {
        console.error('🚨 初始化告警WebSocket失败:', error)
        this.wsConnected = false
      }
    },
    
    // 处理实时告警消息
    handleRealtimeAlert(message) {
      try {
        console.log('📨 处理WebSocket消息:', message)
        console.log('📨 消息类型:', message.type)
        console.log('📨 消息数据:', message.data)
        
        // 根据消息类型处理不同的告警
        if (message.type === 'new_alert') {
          console.log('🚨 收到新告警推送:', message.data)
          console.log('🚨 告警ID:', message.data.alertId)
          console.log('🚨 指标代码:', message.data.indicator)
          this.handleNewAlertEvent(message.data)
        } else if (message.type === 'alert_update') {
          console.log('🔄 收到告警更新推送:', message.data)
          this.handleAlertUpdateEvent(message.data)
        } else if (message.type === 'stats_update') {
          console.log('📊 收到统计更新推送:', message.data)
          this.handleStatsUpdateEvent(message.data)
        } else if (message.type === 'connected') {
          console.log('✅ WebSocket连接确认:', message.message)
        } else if (message.type === 'pong') {
          console.log('🏓 收到心跳响应')
        } else {
          console.log('❓ 未知消息类型:', message.type, message.data)
        }
      } catch (error) {
        console.error('处理实时告警消息失败:', error)
      }
    },
    
    // 关闭WebSocket连接
    closeWebSocketConnection() {
      this.stopHeartbeat()
      wsManager.closeConnection('alerts')
      this.wsConnected = false
    },

    // 设置事件监听器
    setupEventListeners() {
      // 只监听告警更新和统计更新事件，新告警事件由WebSocket直接处理
      // 监听告警更新事件
      window.addEventListener('alertUpdate', (event) => {
        console.log('🔄 收到告警更新事件:', event.detail)
        this.handleAlertUpdateEvent(event.detail)
      })

      // 监听统计更新事件
      window.addEventListener('statsUpdate', (event) => {
        console.log('📊 收到统计更新事件:', event.detail)
        this.handleStatsUpdateEvent(event.detail)
      })
    },

    // 处理新告警事件
    handleNewAlertEvent(alertData) {
      if (alertData && alertData.alertId) {
        console.log('🚨 处理新告警数据:', alertData)
        const chineseIndicator = this.mapIndicatorToChinese(alertData.indicator)
        // 转换后端数据格式为前端格式
        const alert = {
          alertId: alertData.alertId,
          title: chineseIndicator + '异常', // 使用中文指标名称生成标题
          description: chineseIndicator + '值 ' + alertData.currentValue + ' 超出正常范围 ' + alertData.normalRange, // 生成描述
          device: this.formatDeviceId(alertData.deviceId), // 格式化设备ID显示
          deviceId: alertData.deviceId,
          indicator: alertData.indicator, // 保留原始指标代码
          indicatorChinese: chineseIndicator, // 添加中文指标名称
          currentValue: alertData.currentValue,
          normalRange: alertData.normalRange,
          level: this.mapSeverityToLevel(alertData.severity),
          severity: alertData.severity,
          status: alertData.status || 1,
          createTime: alertData.createTime ? new Date(alertData.createTime).toISOString() : new Date().toISOString(),
          time: alertData.createTime ? new Date(alertData.createTime) : new Date(),
          handlerId: 'system', // 默认处理人
          handleTime: null // 处理时间为空
        }
        
        console.log('✅ 添加新告警到列表:', alert)
        
        // 直接添加到主告警列表（统一数据管理）
        this.addAlert(alert)
        
        // 实时告警添加后，重新从后端获取统计数据
        this.updateStatsFromBackend()
        
        // 触发自定义事件，通知页面有新告警（用于高亮效果等）
        const event = new CustomEvent('newAlert', { detail: alert })
        window.dispatchEvent(event)
        
        console.log('📡 实时告警已添加到主列表，当前数量:', this.alertList.length)
        console.log('📡 已触发newAlert事件通知页面')
      }
    },

    // 处理告警更新事件
    handleAlertUpdateEvent(updateData) {
      if (updateData && updateData.alertId) {
        this.updateAlert(updateData.alertId, {
          status: updateData.status,
          handlerId: updateData.handlerId,
          handleTime: updateData.updateTime ? new Date(updateData.updateTime) : new Date()
        })
      }
    },

    // 处理统计更新事件
    handleStatsUpdateEvent(statsData) {
      if (statsData) {
        this.alertStats = {
          total: statsData.total || 0,
          unhandled: statsData.unhandled || 0,
          confirmed: statsData.confirmed || 0,
          handled: statsData.handled || 0
        }
      }
    },

    // 开始心跳检测
    startHeartbeat() {
      this.heartbeatInterval = setInterval(() => {
        if (this.wsConnected) {
          wsManager.sendHeartbeat()
        }
      }, 30000) // 每30秒发送一次心跳
    },

    // 停止心跳检测
    stopHeartbeat() {
      if (this.heartbeatInterval) {
        clearInterval(this.heartbeatInterval)
        this.heartbeatInterval = null
      }
    },

    // 映射指标代码为中文
    mapIndicatorToChinese(indicator) {
      const indicatorMap = {
        'TEMP': '温度',
        'TEMPERATURE': '温度',
        'TURBIDITY': '浊度',
        'PH': 'pH值',
        'pH': 'pH值',
        'pH值': 'pH值'
      }
      return indicatorMap[indicator] || indicator || '未知指标'
    }
  }
})
